home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 52 / Amiga Format AFCD52 (Issue 136, May 2000).iso / -screenplay- / shareware / warpquake / warpquakesrc / gl_vidlinuxglx.c < prev    next >
C/C++ Source or Header  |  2000-02-29  |  22KB  |  998 lines
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20. #include <termios.h>
  21. #include <sys/ioctl.h>
  22. #include <sys/stat.h>
  23. #include <sys/vt.h>
  24. #include <stdarg.h>
  25. #include <stdio.h>
  26. #include <signal.h>
  27.  
  28. #include <dlfcn.h>
  29.  
  30. #include "quakedef.h"
  31.  
  32. #include <GL/glx.h>
  33.  
  34. #include <X11/keysym.h>
  35. #include <X11/cursorfont.h>
  36.  
  37. #include <X11/extensions/xf86dga.h>
  38. #include <X11/extensions/xf86vmode.h>
  39.  
  40. #define WARP_WIDTH              320
  41. #define WARP_HEIGHT             200
  42.  
  43. static Display *dpy = NULL;
  44. static int scrnum;
  45. static Window win;
  46. static GLXContext ctx = NULL;
  47.  
  48. #define KEY_MASK (KeyPressMask | KeyReleaseMask)
  49. #define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
  50.             PointerMotionMask | ButtonMotionMask )
  51. #define X_MASK (KEY_MASK | MOUSE_MASK | VisibilityChangeMask | StructureNotifyMask )
  52.  
  53.  
  54. unsigned short    d_8to16table[256];
  55. unsigned        d_8to24table[256];
  56. unsigned char    d_15to8table[65536];
  57.  
  58. cvar_t    vid_mode = {"vid_mode","0",false};
  59.  
  60. static qboolean        mouse_avail;
  61. static qboolean        mouse_active;
  62. static int   mx, my;
  63. static int    old_mouse_x, old_mouse_y;
  64.  
  65. static cvar_t in_mouse = {"in_mouse", "1", false};
  66. static cvar_t in_dgamouse = {"in_dgamouse", "1", false};
  67. static cvar_t m_filter = {"m_filter", "0"};
  68.  
  69. qboolean dgamouse = false;
  70. qboolean vidmode_ext = false;
  71.  
  72. static int win_x, win_y;
  73.  
  74. static int scr_width, scr_height;
  75.  
  76. static XF86VidModeModeInfo **vidmodes;
  77. static int default_dotclock_vidmode;
  78. static int num_vidmodes;
  79. static qboolean vidmode_active = false;
  80.  
  81. /*-----------------------------------------------------------------------*/
  82.  
  83. //int        texture_mode = GL_NEAREST;
  84. //int        texture_mode = GL_NEAREST_MIPMAP_NEAREST;
  85. //int        texture_mode = GL_NEAREST_MIPMAP_LINEAR;
  86. int        texture_mode = GL_LINEAR;
  87. //int        texture_mode = GL_LINEAR_MIPMAP_NEAREST;
  88. //int        texture_mode = GL_LINEAR_MIPMAP_LINEAR;
  89.  
  90. int        texture_extension_number = 1;
  91.  
  92. float        gldepthmin, gldepthmax;
  93.  
  94. cvar_t    gl_ztrick = {"gl_ztrick","1"};
  95.  
  96. const char *gl_vendor;
  97. const char *gl_renderer;
  98. const char *gl_version;
  99. const char *gl_extensions;
  100.  
  101. void (*qglColorTableEXT) (int, int, int, int, int, const void*);
  102. void (*qgl3DfxSetPaletteEXT) (GLuint *);
  103.  
  104. static float vid_gamma = 1.0;
  105.  
  106. qboolean is8bit = false;
  107. qboolean isPermedia = false;
  108. qboolean gl_mtexable = false;
  109.  
  110. /*-----------------------------------------------------------------------*/
  111. void D_BeginDirectRect (int x, int y, byte *pbitmap, int width, int height)
  112. {
  113. }
  114.  
  115. void D_EndDirectRect (int x, int y, int width, int height)
  116. {
  117. }
  118.  
  119. static int XLateKey(XKeyEvent *ev)
  120. {
  121.  
  122.     int key;
  123.     char buf[64];
  124.     KeySym keysym;
  125.  
  126.     key = 0;
  127.  
  128.     XLookupString(ev, buf, sizeof buf, &keysym, 0);
  129.  
  130.     switch(keysym)
  131.     {
  132.         case XK_KP_Page_Up:     
  133.         case XK_Page_Up:     key = K_PGUP; break;
  134.  
  135.         case XK_KP_Page_Down: 
  136.         case XK_Page_Down:     key = K_PGDN; break;
  137.  
  138.         case XK_KP_Home: 
  139.         case XK_Home:     key = K_HOME; break;
  140.  
  141.         case XK_KP_End:  
  142.         case XK_End:     key = K_END; break;
  143.  
  144.         case XK_KP_Left: 
  145.         case XK_Left:     key = K_LEFTARROW; break;
  146.  
  147.         case XK_KP_Right: 
  148.         case XK_Right:    key = K_RIGHTARROW;        break;
  149.  
  150.         case XK_KP_Down: 
  151.         case XK_Down:     key = K_DOWNARROW; break;
  152.  
  153.         case XK_KP_Up:   
  154.         case XK_Up:         key = K_UPARROW;     break;
  155.  
  156.         case XK_Escape: key = K_ESCAPE;        break;
  157.  
  158.         case XK_KP_Enter: 
  159.         case XK_Return: key = K_ENTER;         break;
  160.  
  161.         case XK_Tab:        key = K_TAB;             break;
  162.  
  163.         case XK_F1:         key = K_F1;                break;
  164.  
  165.         case XK_F2:         key = K_F2;                break;
  166.  
  167.         case XK_F3:         key = K_F3;                break;
  168.  
  169.         case XK_F4:         key = K_F4;                break;
  170.  
  171.         case XK_F5:         key = K_F5;                break;
  172.  
  173.         case XK_F6:         key = K_F6;                break;
  174.  
  175.         case XK_F7:         key = K_F7;                break;
  176.  
  177.         case XK_F8:         key = K_F8;                break;
  178.  
  179.         case XK_F9:         key = K_F9;                break;
  180.  
  181.         case XK_F10:        key = K_F10;             break;
  182.  
  183.         case XK_F11:        key = K_F11;             break;
  184.  
  185.         case XK_F12:        key = K_F12;             break;
  186.  
  187.         case XK_BackSpace: key = K_BACKSPACE; break;
  188.  
  189.         case XK_KP_Delete: 
  190.         case XK_Delete: key = K_DEL; break;
  191.  
  192.         case XK_Pause:    key = K_PAUSE;         break;
  193.  
  194.         case XK_Shift_L:
  195.         case XK_Shift_R:    key = K_SHIFT;        break;
  196.  
  197.         case XK_Execute: 
  198.         case XK_Control_L: 
  199.         case XK_Control_R:    key = K_CTRL;         break;
  200.  
  201.         case XK_Alt_L:    
  202.         case XK_Meta_L: 
  203.         case XK_Alt_R:    
  204.         case XK_Meta_R: key = K_ALT;            break;
  205.  
  206.         case XK_KP_Begin: key = '5';    break;
  207.  
  208.         case XK_KP_Insert: 
  209.         case XK_Insert:key = K_INS; break;
  210.  
  211.         case XK_KP_Multiply: key = '*'; break;
  212.         case XK_KP_Add:  key = '+'; break;
  213.         case XK_KP_Subtract: key = '-'; break;
  214.         case XK_KP_Divide: key = '/'; break;
  215.  
  216. #if 0
  217.         case 0x021: key = '1';break;/* [!] */
  218.         case 0x040: key = '2';break;/* [@] */
  219.         case 0x023: key = '3';break;/* [#] */
  220.         case 0x024: key = '4';break;/* [$] */
  221.         case 0x025: key = '5';break;/* [%] */
  222.         case 0x05e: key = '6';break;/* [^] */
  223.         case 0x026: key = '7';break;/* [&] */
  224.         case 0x02a: key = '8';break;/* [*] */
  225.         case 0x028: key = '9';;break;/* [(] */
  226.         case 0x029: key = '0';break;/* [)] */
  227.         case 0x05f: key = '-';break;/* [_] */
  228.         case 0x02b: key = '=';break;/* [+] */
  229.         case 0x07c: key = '\'';break;/* [|] */
  230.         case 0x07d: key = '[';break;/* [}] */
  231.         case 0x07b: key = ']';break;/* [{] */
  232.         case 0x022: key = '\'';break;/* ["] */
  233.         case 0x03a: key = ';';break;/* [:] */
  234.         case 0x03f: key = '/';break;/* [?] */
  235.         case 0x03e: key = '.';break;/* [>] */
  236.         case 0x03c: key = ',';break;/* [<] */
  237. #endif
  238.  
  239.         default:
  240.             key = *(unsigned char*)buf;
  241.             if (key >= 'A' && key <= 'Z')
  242.                 key = key - 'A' + 'a';
  243.             break;
  244.     } 
  245.  
  246.     return key;
  247. }
  248.  
  249. static Cursor CreateNullCursor(Display *display, Window root)
  250. {
  251.     Pixmap cursormask; 
  252.     XGCValues xgc;
  253.     GC gc;
  254.     XColor dummycolour;
  255.     Cursor cursor;
  256.  
  257.     cursormask = XCreatePixmap(display, root, 1, 1, 1/*depth*/);
  258.     xgc.function = GXclear;
  259.     gc =  XCreateGC(display, cursormask, GCFunction, &xgc);
  260.     XFillRectangle(display, cursormask, gc, 0, 0, 1, 1);
  261.     dummycolour.pixel = 0;
  262.     dummycolour.red = 0;
  263.     dummycolour.flags = 04;
  264.     cursor = XCreatePixmapCursor(display, cursormask, cursormask,
  265.           &dummycolour,&dummycolour, 0,0);
  266.     XFreePixmap(display,cursormask);
  267.     XFreeGC(display,gc);
  268.     return cursor;
  269. }
  270.  
  271. static void install_grabs(void)
  272. {
  273.  
  274. // inviso cursor
  275.     XDefineCursor(dpy, win, CreateNullCursor(dpy, win));
  276.  
  277.     XGrabPointer(dpy, win,
  278.                  True,
  279.                  0,
  280.                  GrabModeAsync, GrabModeAsync,
  281.                  win,
  282.                  None,
  283.                  CurrentTime);
  284.  
  285.     if (in_dgamouse.value) {
  286.         int MajorVersion, MinorVersion;
  287.  
  288.         if (!XF86DGAQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
  289.             // unable to query, probalby not supported
  290.             Con_Printf( "Failed to detect XF86DGA Mouse\n" );
  291.             in_dgamouse.value = 0;
  292.         } else {
  293.             dgamouse = true;
  294.             XF86DGADirectVideo(dpy, DefaultScreen(dpy), XF86DGADirectMouse);
  295.             XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
  296.         }
  297.     } else {
  298.         XWarpPointer(dpy, None, win,
  299.                      0, 0, 0, 0,
  300.                      vid.width / 2, vid.height / 2);
  301.     }
  302.  
  303.     XGrabKeyboard(dpy, win,
  304.                   False,
  305.                   GrabModeAsync, GrabModeAsync,
  306.                   CurrentTime);
  307.  
  308.     mouse_active = true;
  309.  
  310. //    XSync(dpy, True);
  311. }
  312.  
  313. static void uninstall_grabs(void)
  314. {
  315.     if (!dpy || !win)
  316.         return;
  317.  
  318.     if (dgamouse) {
  319.         dgamouse = false;
  320.         XF86DGADirectVideo(dpy, DefaultScreen(dpy), 0);
  321.     }
  322.  
  323.     XUngrabPointer(dpy, CurrentTime);
  324.     XUngrabKeyboard(dpy, CurrentTime);
  325.  
  326. // inviso cursor
  327.     XUndefineCursor(dpy, win);
  328.  
  329.     mouse_active = false;
  330. }
  331.  
  332. static void HandleEvents(void)
  333. {
  334.     XEvent event;
  335.     KeySym ks;
  336.     int b;
  337.     qboolean dowarp = false;
  338.     int mwx = vid.width/2;
  339.     int mwy = vid.height/2;
  340.  
  341.     if (!dpy)
  342.         return;
  343.  
  344.     while (XPending(dpy)) {
  345.         XNextEvent(dpy, &event);
  346.  
  347.         switch (event.type) {
  348.         case KeyPress:
  349.         case KeyRelease:
  350.             Key_Event(XLateKey(&event.xkey), event.type == KeyPress);
  351.             break;
  352.  
  353.         case MotionNotify:
  354.             if (mouse_active) {
  355.                 if (dgamouse) {
  356.                     mx += (event.xmotion.x + win_x) * 2;
  357.                     my += (event.xmotion.y + win_y) * 2;
  358.                 } 
  359.                 else 
  360.                 {
  361.                     mx += ((int)event.xmotion.x - mwx) * 2;
  362.                     my += ((int)event.xmotion.y - mwy) * 2;
  363.                     mwx = event.xmotion.x;
  364.                     mwy = event.xmotion.y;
  365.  
  366.                     if (mx || my)
  367.                         dowarp = true;
  368.                 }
  369.             }
  370.             break;
  371.  
  372.             break;
  373.  
  374.         case ButtonPress:
  375.             b=-1;
  376.             if (event.xbutton.button == 1)
  377.                 b = 0;
  378.             else if (event.xbutton.button == 2)
  379.                 b = 2;
  380.             else if (event.xbutton.button == 3)
  381.                 b = 1;
  382.             if (b>=0)
  383.                 Key_Event(K_MOUSE1 + b, true);
  384.             break;
  385.  
  386.         case ButtonRelease:
  387.             b=-1;
  388.             if (event.xbutton.button == 1)
  389.                 b = 0;
  390.             else if (event.xbutton.button == 2)
  391.                 b = 2;
  392.             else if (event.xbutton.button == 3)
  393.                 b = 1;
  394.             if (b>=0)
  395.                 Key_Event(K_MOUSE1 + b, false);
  396.             break;
  397.  
  398.         case CreateNotify :
  399.             win_x = event.xcreatewindow.x;
  400.             win_y = event.xcreatewindow.y;
  401.             break;
  402.  
  403.         case ConfigureNotify :
  404.             win_x = event.xconfigure.x;
  405.             win_y = event.xconfigure.y;
  406.             break;
  407.         }
  408.     }
  409.  
  410.     if (dowarp) {
  411.         /* move the mouse to the window center again */
  412.         XWarpPointer(dpy, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
  413.     }
  414.  
  415. }
  416.  
  417. static void IN_DeactivateMouse( void ) 
  418. {
  419.     if (!mouse_avail || !dpy || !win)
  420.         return;
  421.  
  422.     if (mouse_active) {
  423.         uninstall_grabs();
  424.         mouse_active = false;
  425.     }
  426. }
  427.  
  428. static void IN_ActivateMouse( void ) 
  429. {
  430.     if (!mouse_avail || !dpy || !win)
  431.         return;
  432.  
  433.     if (!mouse_active) {
  434.         mx = my = 0; // don't spazz
  435.         install_grabs();
  436.         mouse_active = true;
  437.     }
  438. }
  439.  
  440.  
  441. void VID_Shutdown(void)
  442. {
  443.     if (!ctx || !dpy)
  444.         return;
  445.     IN_DeactivateMouse();
  446.     if (dpy) {
  447.         if (ctx)
  448.             glXDestroyContext(dpy, ctx);
  449.         if (win)
  450.             XDestroyWindow(dpy, win);
  451.         if (vidmode_active)
  452.             XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[0]);
  453.         XCloseDisplay(dpy);
  454.     }
  455.     vidmode_active = false;
  456.     dpy = NULL;
  457.     win = 0;
  458.     ctx = NULL;
  459. }
  460.  
  461. void signal_handler(int sig)
  462. {
  463.     printf("Received signal %d, exiting...\n", sig);
  464.     Sys_Quit();
  465.     exit(0);
  466. }
  467.  
  468. void InitSig(void)
  469. {
  470.     signal(SIGHUP, signal_handler);
  471.     signal(SIGINT, signal_handler);
  472.     signal(SIGQUIT, signal_handler);
  473.     signal(SIGILL, signal_handler);
  474.     signal(SIGTRAP, signal_handler);
  475.     signal(SIGIOT, signal_handler);
  476.     signal(SIGBUS, signal_handler);
  477.     signal(SIGFPE, signal_handler);
  478.     signal(SIGSEGV, signal_handler);
  479.     signal(SIGTERM, signal_handler);
  480. }
  481.  
  482. void VID_ShiftPalette(unsigned char *p)
  483. {
  484. //    VID_SetPalette(p);
  485. }
  486.  
  487. void    VID_SetPalette (unsigned char *palette)
  488. {
  489.     byte    *pal;
  490.     unsigned r,g,b;
  491.     unsigned v;
  492.     int     r1,g1,b1;
  493.     int        j,k,l,m;
  494.     unsigned short i;
  495.     unsigned    *table;
  496.     FILE *f;
  497.     char s[255];
  498.     int dist, bestdist;
  499.  
  500. //
  501. // 8 8 8 encoding
  502. //
  503.     pal = palette;
  504.     table = d_8to24table;
  505.     for (i=0 ; i<256 ; i++)
  506.     {
  507.         r = pal[0];
  508.         g = pal[1];
  509.         b = pal[2];
  510.         pal += 3;
  511.         
  512.         v = (255<<24) + (r<<0) + (g<<8) + (b<<16);
  513.         *table++ = v;
  514.     }
  515.     d_8to24table[255] &= 0xffffff;    // 255 is transparent
  516.  
  517.     for (i=0; i < (1<<15); i++) {
  518.         /* Maps
  519.         000000000000000
  520.         000000000011111 = Red  = 0x1F
  521.         000001111100000 = Blue = 0x03E0
  522.         111110000000000 = Grn  = 0x7C00
  523.         */
  524.         r = ((i & 0x1F) << 3)+4;
  525.         g = ((i & 0x03E0) >> 2)+4;
  526.         b = ((i & 0x7C00) >> 7)+4;
  527.         pal = (unsigned char *)d_8to24table;
  528.         for (v=0,k=0,bestdist=10000*10000; v<256; v++,pal+=4) {
  529.             r1 = (int)r - (int)pal[0];
  530.             g1 = (int)g - (int)pal[1];
  531.             b1 = (int)b - (int)pal[2];
  532.             dist = (r1*r1)+(g1*g1)+(b1*b1);
  533.             if (dist < bestdist) {
  534.                 k=v;
  535.                 bestdist = dist;
  536.             }
  537.         }
  538.         d_15to8table[i]=k;
  539.     }
  540. }
  541.  
  542. void CheckMultiTextureExtensions(void) 
  543. {
  544.     void *prjobj;
  545.  
  546.     if (strstr(gl_extensions, "GL_SGIS_multitexture ") && !COM_CheckParm("-nomtex")) {
  547.         Con_Printf("Found GL_SGIS_multitexture...\n");
  548.  
  549.         if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL) {
  550.             Con_Printf("Unable to open symbol list for main program.\n");
  551.             return;
  552.         }
  553.  
  554.         qglMTexCoord2fSGIS = (void *) dlsym(prjobj, "glMTexCoord2fSGIS");
  555.         qglSelectTextureSGIS = (void *) dlsym(prjobj, "glSelectTextureSGIS");
  556.  
  557.         if (qglMTexCoord2fSGIS && qglSelectTextureSGIS) {
  558.             Con_Printf("Multitexture extensions found.\n");
  559.             gl_mtexable = true;
  560.         } else
  561.             Con_Printf("Symbol not found, disabled.\n");
  562.  
  563.         dlclose(prjobj);
  564.     }
  565. }
  566.  
  567. /*
  568. ===============
  569. GL_Init
  570. ===============
  571. */
  572. void GL_Init (void)
  573. {
  574.     gl_vendor = glGetString (GL_VENDOR);
  575.     Con_Printf ("GL_VENDOR: %s\n", gl_vendor);
  576.     gl_renderer = glGetString (GL_RENDERER);
  577.     Con_Printf ("GL_RENDERER: %s\n", gl_renderer);
  578.  
  579.     gl_version = glGetString (GL_VERSION);
  580.     Con_Printf ("GL_VERSION: %s\n", gl_version);
  581.     gl_extensions = glGetString (GL_EXTENSIONS);
  582.     Con_Printf ("GL_EXTENSIONS: %s\n", gl_extensions);
  583.  
  584. //    Con_Printf ("%s %s\n", gl_renderer, gl_version);
  585.  
  586.     CheckMultiTextureExtensions ();
  587.  
  588.     glClearColor (1,0,0,0);
  589.     glCullFace(GL_FRONT);
  590.     glEnable(GL_TEXTURE_2D);
  591.  
  592.     glEnable(GL_ALPHA_TEST);
  593.     glAlphaFunc(GL_GREATER, 0.666);
  594.  
  595.     glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
  596.     glShadeModel (GL_FLAT);
  597.  
  598.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  599.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  600.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  601.     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  602.  
  603.     glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
  604.  
  605. //    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  606.     glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
  607. }
  608.  
  609. /*
  610. =================
  611. GL_BeginRendering
  612.  
  613. =================
  614. */
  615. void GL_BeginRendering (int *x, int *y, int *width, int *height)
  616. {
  617.     extern cvar_t gl_clear;
  618.  
  619.     *x = *y = 0;
  620.     *width = scr_width;
  621.     *height = scr_height;
  622.  
  623. //    if (!wglMakeCurrent( maindc, baseRC ))
  624. //        Sys_Error ("wglMakeCurrent failed");
  625.  
  626. //    glViewport (*x, *y, *width, *height);
  627. }
  628.  
  629.  
  630. void GL_EndRendering (void)
  631. {
  632.     glFlush();
  633.     glXSwapBuffers(dpy, win);
  634. }
  635.  
  636. qboolean VID_Is8bit(void)
  637. {
  638.     return is8bit;
  639. }
  640.  
  641. void VID_Init8bitPalette(void) 
  642. {
  643.     // Check for 8bit Extensions and initialize them.
  644.     int i;
  645.     void *prjobj;
  646.  
  647.     if ((prjobj = dlopen(NULL, RTLD_LAZY)) == NULL) {
  648.         Con_Printf("Unable to open symbol list for main program.\n");
  649.         return;
  650.     }
  651.  
  652.     if (strstr(gl_extensions, "3DFX_set_global_palette") &&
  653.         (qgl3DfxSetPaletteEXT = dlsym(prjobj, "gl3DfxSetPaletteEXT")) != NULL) {
  654.         GLubyte table[256][4];
  655.         char *oldpal;
  656.  
  657.         Con_SafePrintf("8-bit GL extensions enabled.\n");
  658.         glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
  659.         oldpal = (char *) d_8to24table; //d_8to24table3dfx;
  660.         for (i=0;i<256;i++) {
  661.             table[i][2] = *oldpal++;
  662.             table[i][1] = *oldpal++;
  663.             table[i][0] = *oldpal++;
  664.             table[i][3] = 255;
  665.             oldpal++;
  666.         }
  667.         qgl3DfxSetPaletteEXT((GLuint *)table);
  668.         is8bit = true;
  669.  
  670.     } else if (strstr(gl_extensions, "GL_EXT_shared_texture_palette") &&
  671.         (qglColorTableEXT = dlsym(prjobj, "glColorTableEXT")) != NULL) {
  672.         char thePalette[256*3];
  673.         char *oldPalette, *newPalette;
  674.  
  675.         Con_SafePrintf("8-bit GL extensions enabled.\n");
  676.         glEnable( GL_SHARED_TEXTURE_PALETTE_EXT );
  677.         oldPalette = (char *) d_8to24table; //d_8to24table3dfx;
  678.         newPalette = thePalette;
  679.         for (i=0;i<256;i++) {
  680.             *newPalette++ = *oldPalette++;
  681.             *newPalette++ = *oldPalette++;
  682.             *newPalette++ = *oldPalette++;
  683.             oldPalette++;
  684.         }
  685.         qglColorTableEXT(GL_SHARED_TEXTURE_PALETTE_EXT, GL_RGB, 256, GL_RGB, GL_UNSIGNED_BYTE, (void *) thePalette);
  686.         is8bit = true;
  687.     }
  688.     
  689.     dlclose(prjobj);
  690. }
  691.  
  692. static void Check_Gamma (unsigned char *pal)
  693. {
  694.     float    f, inf;
  695.     unsigned char    palette[768];
  696.     int        i;
  697.  
  698.     if ((i = COM_CheckParm("-gamma")) == 0) {
  699.         if ((gl_renderer && strstr(gl_renderer, "Voodoo")) ||
  700.             (gl_vendor && strstr(gl_vendor, "3Dfx")))
  701.             vid_gamma = 1;
  702.         else
  703.             vid_gamma = 0.7; // default to 0.7 on non-3dfx hardware
  704.     } else
  705.         vid_gamma = Q_atof(com_argv[i+1]);
  706.  
  707.     for (i=0 ; i<768 ; i++)
  708.     {
  709.         f = pow ( (pal[i]+1)/256.0 , vid_gamma );
  710.         inf = f*255 + 0.5;
  711.         if (inf < 0)
  712.             inf = 0;
  713.         if (inf > 255)
  714.             inf = 255;
  715.         palette[i] = inf;
  716.     }
  717.  
  718.     memcpy (pal, palette, sizeof(palette));
  719. }
  720.  
  721. void VID_Init(unsigned char *palette)
  722. {
  723.     int i;
  724.     int attrib[] = {
  725.         GLX_RGBA,
  726.         GLX_RED_SIZE, 1,
  727.         GLX_GREEN_SIZE, 1,
  728.         GLX_BLUE_SIZE, 1,
  729.         GLX_DOUBLEBUFFER,
  730.         GLX_DEPTH_SIZE, 1,
  731.         None
  732.     };
  733.     char    gldir[MAX_OSPATH];
  734.     int width = 640, height = 480;
  735.     XSetWindowAttributes attr;
  736.     unsigned long mask;
  737.     Window root;
  738.     XVisualInfo *visinfo;
  739.     qboolean fullscreen = true;
  740.     int MajorVersion, MinorVersion;
  741.     int actualWidth, actualHeight;
  742.  
  743.     Cvar_RegisterVariable (&vid_mode);
  744.     Cvar_RegisterVariable (&in_mouse);
  745.     Cvar_RegisterVariable (&in_dgamouse);
  746.     Cvar_RegisterVariable (&m_filter);
  747.     Cvar_RegisterVariable (&gl_ztrick);
  748.     
  749.     vid.maxwarpwidth = WARP_WIDTH;
  750.     vid.maxwarpheight = WARP_HEIGHT;
  751.     vid.colormap = host_colormap;
  752.     vid.fullbright = 256 - LittleLong (*((int *)vid.colormap + 2048));
  753.  
  754. // interpret command-line params
  755.  
  756. // set vid parameters
  757.     if ((i = COM_CheckParm("-window")) != 0)
  758.         fullscreen = false;
  759.  
  760.     if ((i = COM_CheckParm("-width")) != 0)
  761.         width = atoi(com_argv[i+1]);
  762.  
  763.     if ((i = COM_CheckParm("-height")) != 0)
  764.         height = atoi(com_argv[i+1]);
  765.  
  766.     if ((i = COM_CheckParm("-conwidth")) != 0)
  767.         vid.conwidth = Q_atoi(com_argv[i+1]);
  768.     else
  769.         vid.conwidth = 640;
  770.  
  771.     vid.conwidth &= 0xfff8; // make it a multiple of eight
  772.  
  773.     if (vid.conwidth < 320)
  774.         vid.conwidth = 320;
  775.  
  776.     // pick a conheight that matches with correct aspect
  777.     vid.conheight = vid.conwidth*3 / 4;
  778.  
  779.     if ((i = COM_CheckParm("-conheight")) != 0)
  780.         vid.conheight = Q_atoi(com_argv[i+1]);
  781.     if (vid.conheight < 200)
  782.         vid.conheight = 200;
  783.  
  784.     if (!(dpy = XOpenDisplay(NULL))) {
  785.         fprintf(stderr, "Error couldn't open the X display\n");
  786.         exit(1);
  787.     }
  788.  
  789.     scrnum = DefaultScreen(dpy);
  790.     root = RootWindow(dpy, scrnum);
  791.  
  792.     // Get video mode list
  793.     MajorVersion = MinorVersion = 0;
  794.     if (!XF86VidModeQueryVersion(dpy, &MajorVersion, &MinorVersion)) { 
  795.         vidmode_ext = false;
  796.     } else {
  797.         Con_Printf("Using XFree86-VidModeExtension Version %d.%d\n", MajorVersion, MinorVersion);
  798.         vidmode_ext = true;
  799.     }
  800.  
  801.     visinfo = glXChooseVisual(dpy, scrnum, attrib);
  802.     if (!visinfo) {
  803.         fprintf(stderr, "qkHack: Error couldn't get an RGB, Double-buffered, Depth visual\n");
  804.         exit(1);
  805.     }
  806.  
  807.     if (vidmode_ext) {
  808.         int best_fit, best_dist, dist, x, y;
  809.         
  810.         XF86VidModeGetAllModeLines(dpy, scrnum, &num_vidmodes, &vidmodes);
  811.  
  812.         // Are we going fullscreen?  If so, let's change video mode
  813.         if (fullscreen) {
  814.             best_dist = 9999999;
  815.             best_fit = -1;
  816.  
  817.             for (i = 0; i < num_vidmodes; i++) {
  818.                 if (width > vidmodes[i]->hdisplay ||
  819.                     height > vidmodes[i]->vdisplay)
  820.                     continue;
  821.  
  822.                 x = width - vidmodes[i]->hdisplay;
  823.                 y = height - vidmodes[i]->vdisplay;
  824.                 dist = (x * x) + (y * y);
  825.                 if (dist < best_dist) {
  826.                     best_dist = dist;
  827.                     best_fit = i;
  828.                 }
  829.             }
  830.  
  831.             if (best_fit != -1) {
  832.                 actualWidth = vidmodes[best_fit]->hdisplay;
  833.                 actualHeight = vidmodes[best_fit]->vdisplay;
  834.  
  835.                 // change to the mode
  836.                 XF86VidModeSwitchToMode(dpy, scrnum, vidmodes[best_fit]);
  837.                 vidmode_active = true;
  838.  
  839.                 // Move the viewport to top left
  840.                 XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
  841.             } else
  842.                 fullscreen = 0;
  843.         }
  844.     }
  845.  
  846.     /* window attributes */
  847.     attr.background_pixel = 0;
  848.     attr.border_pixel = 0;
  849.     attr.colormap = XCreateColormap(dpy, root, visinfo->visual, AllocNone);
  850.     attr.event_mask = X_MASK;
  851.     if (vidmode_active) {
  852.         mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | 
  853.             CWEventMask | CWOverrideRedirect;
  854.         attr.override_redirect = True;
  855.         attr.backing_store = NotUseful;
  856.         attr.save_under = False;
  857.     } else
  858.         mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
  859.  
  860.     win = XCreateWindow(dpy, root, 0, 0, width, height,
  861.                         0, visinfo->depth, InputOutput,
  862.                         visinfo->visual, mask, &attr);
  863.     XMapWindow(dpy, win);
  864.  
  865.     if (vidmode_active) {
  866.         XMoveWindow(dpy, win, 0, 0);
  867.         XRaiseWindow(dpy, win);
  868.         XWarpPointer(dpy, None, win, 0, 0, 0, 0, 0, 0);
  869.         XFlush(dpy);
  870.         // Move the viewport to top left
  871.         XF86VidModeSetViewPort(dpy, scrnum, 0, 0);
  872.     }
  873.  
  874.     XFlush(dpy);
  875.  
  876.     ctx = glXCreateContext(dpy, visinfo, NULL, True);
  877.  
  878.     glXMakeCurrent(dpy, win, ctx);
  879.  
  880.     scr_width = width;
  881.     scr_height = height;
  882.  
  883.     if (vid.conheight > height)
  884.         vid.conheight = height;
  885.     if (vid.conwidth > width)
  886.         vid.conwidth = width;
  887.     vid.width = vid.conwidth;
  888.     vid.height = vid.conheight;
  889.  
  890.     vid.aspect = ((float)vid.height / (float)vid.width) * (320.0 / 240.0);
  891.     vid.numpages = 2;
  892.  
  893.     InitSig(); // trap evil signals
  894.  
  895.     GL_Init();
  896.  
  897.     sprintf (gldir, "%s/glquake", com_gamedir);
  898.     Sys_mkdir (gldir);
  899.  
  900.     VID_SetPalette(palette);
  901.  
  902.     // Check for 3DFX Extensions and initialize them.
  903.     VID_Init8bitPalette();
  904.  
  905.     Con_SafePrintf ("Video mode %dx%d initialized.\n", width, height);
  906.  
  907.     vid.recalc_refdef = 1;                // force a surface cache flush
  908. }
  909.  
  910. void Sys_SendKeyEvents(void)
  911. {
  912.     HandleEvents();
  913. }
  914.  
  915. void Force_CenterView_f (void)
  916. {
  917.     cl.viewangles[PITCH] = 0;
  918. }
  919.  
  920. void IN_Init(void)
  921. {
  922. }
  923.  
  924. void IN_Shutdown(void)
  925. {
  926. }
  927.  
  928. /*
  929. ===========
  930. IN_Commands
  931. ===========
  932. */
  933. void IN_Commands (void)
  934. {
  935.     if (!dpy || !win)
  936.         return;
  937.  
  938.     if (vidmode_active || key_dest == key_game)
  939.         IN_ActivateMouse();
  940.     else
  941.         IN_DeactivateMouse ();
  942. }
  943.  
  944. /*
  945. ===========
  946. IN_Move
  947. ===========
  948. */
  949. void IN_MouseMove (usercmd_t *cmd)
  950. {
  951.     if (!mouse_avail)
  952.         return;
  953.    
  954.     if (m_filter.value)
  955.     {
  956.         mx = (mx + old_mouse_x) * 0.5;
  957.         my = (my + old_mouse_y) * 0.5;
  958.     }
  959.     old_mouse_x = mx;
  960.     old_mouse_y = my;
  961.  
  962.     mx *= sensitivity.value;
  963.     my *= sensitivity.value;
  964.  
  965. // add mouse X/Y movement to cmd
  966.     if ( (in_strafe.state & 1) || (lookstrafe.value && (in_mlook.state & 1) ))
  967.         cmd->sidemove += m_side.value * mx;
  968.     else
  969.         cl.viewangles[YAW] -= m_yaw.value * mx;
  970.     
  971.     if (in_mlook.state & 1)
  972.         V_StopPitchDrift ();
  973.         
  974.     if ( (in_mlook.state & 1) && !(in_strafe.state & 1))
  975.     {
  976.         cl.viewangles[PITCH] += m_pitch.value * my;
  977.         if (cl.viewangles[PITCH] > 80)
  978.             cl.viewangles[PITCH] = 80;
  979.         if (cl.viewangles[PITCH] < -70)
  980.             cl.viewangles[PITCH] = -70;
  981.     }
  982.     else
  983.     {
  984.         if ((in_strafe.state & 1) && noclip_anglehack)
  985.             cmd->upmove -= m_forward.value * my;
  986.         else
  987.             cmd->forwardmove -= m_forward.value * my;
  988.     }
  989.     mx = my = 0;
  990. }
  991.  
  992. void IN_Move (usercmd_t *cmd)
  993. {
  994.     IN_MouseMove(cmd);
  995. }
  996.  
  997.  
  998.